/* dircproxy
 * Copyright (C) 2000,2001,2002,2003 Scott James Remnant <scott@netsplit.com>.
 * Copyright (C) 2004, 2005 Francois Harvey <fharvey at securiweb dot net>
 *
 * irc_client.c
 *  - Handling of clients connected to the proxy
 *  - Functions to send data to the client in the correct protocol format
 * --
 * @(#) $Id: irc_client.c,v 1.96 2004/04/24 09:34:37 fharvey Exp $
 *
 * This file is distributed according to the GNU General Public
 * License.  For full details, read the top of 'main.c' or the
 * file called COPYING that was distributed with this code.
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>

#include <dircproxy.h>

#ifdef HAVE_CRYPT_H
# include <crypt.h>
#else /* HAVE_CRYPT_H */
# include <unistd.h>
#endif /* HAVE_CRYPT_H */

#include "sprintf.h"
#include "net.h"
#include "dns.h"
#include "timers.h"
#include "dcc_net.h"
#include "irc_log.h"
#include "irc_net.h"
#include "irc_prot.h"
#include "irc_string.h"
#include "irc_server.h"
#include "irc_client.h"
#include "logo.h"

/* forward declarations */
static void _ircclient_connected2(struct ircproxy *, void *, const char *,
                                  const char *);
static void _ircclient_data(struct ircproxy *, int);
static void _ircclient_error(struct ircproxy *, int, int);
static int _ircclient_detach(struct ircproxy *, const char *);
static int _ircclient_gotmsg(struct ircproxy *, const char *);
static int _ircclient_authenticate(struct ircproxy *, const char *);
static void _ircclient_resetnick(struct ircproxy *, void *);
static int _ircclient_got_details(struct ircproxy *, const char *,
                                  const char *, const char *, const char *);
static int _ircclient_motd(struct ircproxy *);
static void _ircclient_timedout(struct ircproxy *, void *);
static int _ircclient_send_dccreject(struct ircproxy *, const char *,
                                     const char *);
int  _ircclient_handle_privmsg(struct ircproxy *, struct ircmessage);
void _ircclient_handle_recall(struct ircproxy *, struct ircmessage);
void _ircclient_handle_users(struct ircproxy *, struct ircmessage);
void _ircclient_handle_kill(struct ircproxy *, struct ircmessage);
void _ircclient_handle_notify(struct ircproxy *, struct ircmessage);
int  _ircclient_handle_jump(struct ircproxy *, struct ircmessage);
void _ircclient_handle_status(struct ircproxy *, struct ircmessage);
void _ircclient_handle_help(struct ircproxy *, struct ircmessage);

/* New user mode bits */
#define RFC2812_MODE_W 0x04
#define RFC2812_MODE_I 0x08

/* Time/date format for strftime(3) */
#define START_TIMEDATE_FORMAT "%a, %d %b %Y %H:%M:%S %z"

/* Define MIN() */
#ifndef MIN
#define MIN(x, y) ((x) < (y) ? (x) : (y))
#endif /* MIN */

/* Called when a new client has connected */
int ircclient_connected(struct ircproxy *p) {
  char ip[DNS_MAX_HOSTLEN];

  ircclient_send_notice(p, "Looking up your hostname...");

  net_ntop(&p->client_addr, ip, sizeof(ip));
  dns_hostfromaddr(p, 0, ip, (dns_fun_t) _ircclient_connected2);

  return 0;
}

/* Called once a client DNS lookup has completed */
static void _ircclient_connected2(struct ircproxy *p, void *data,
                                  const char *ip, const char *name) {
  p->client_host = x_strdup(name);
  if (!p->hostname)
    p->hostname = x_strdup(name);
  ircclient_send_notice(p, "Got your hostname.");

  p->client_status |= IRC_CLIENT_CONNECTED;
  net_hook(p->client_sock, SOCK_NORMAL, (void *)p,
           ACTIVITY_FUNCTION(_ircclient_data),
           ERROR_FUNCTION(_ircclient_error));

  debug("Client connected from %s", p->client_host);

  timer_new((void *)p, "client_auth", g.client_timeout,
            TIMER_FUNCTION(_ircclient_timedout), (void *)0);
}

/* Called when a client sends us stuff. */
static void _ircclient_data(struct ircproxy *p, int sock) {
  char *str;

  if (sock != p->client_sock) {
    error("Unexpected socket %d in _ircclient_data, expected %d", sock,
          p->client_sock);
    net_close(&sock);
    return;
  }

  str = 0;
  while (!p->dead && (p->client_status & IRC_CLIENT_CONNECTED)
         && net_gets(p->client_sock, &str, "\r\n") > 0) {
    debug(">> '%s'", str);
    _ircclient_gotmsg(p, str);
    free(str);
  }
}

/* Called on client disconnection or error */
static void _ircclient_error(struct ircproxy *p, int sock, int bad) {
  if (sock != p->client_sock) {
    error("Unexpected socket %d in _ircclient_error, expected %d", sock,
          p->client_sock);
    net_close(&sock);
    return;
  }

  if (bad) {
    debug("Socket error");
  } else {
    debug("Client disconnect");
  }

  _ircclient_detach(p, 0);
}

/* Called to detach an irc client */
static int _ircclient_detach(struct ircproxy *p, const char *message) {
  if (p->die_on_close) {
    debug("Killing proxy");

    if (message) {
      ircserver_send_command(p, "QUIT", ":%s", message);
    } else if (p->conn_class && p->conn_class->quit_message) {
      ircserver_send_command(p, "QUIT", ":%s", p->conn_class->quit_message);
    } else {
      ircserver_send_command(p, "QUIT", ":Leaving IRC - %s %s",
                             PACKAGE, VERSION);
    }
    ircserver_close_sock(p);

    p->conn_class = 0;
    ircclient_close(p);

  } else {
    debug("Detaching proxy");
    if (p->client_status == IRC_CLIENT_ACTIVE)
      irclog_log(p, IRC_LOG_CLIENT, IRC_LOGFILE_ALL, PACKAGE,
                 "You disconnected");

    /* Drop modes */
    if ((p->client_status == IRC_CLIENT_ACTIVE)
        && p->conn_class->drop_modes) {
      char *mode;

      mode = x_sprintf("-%s", p->conn_class->drop_modes);
      debug("Auto-mode-change '%s'", mode);

      ircclient_change_mode(p, mode);
      if (p->server_status == IRC_SERVER_ACTIVE)
        ircserver_send_command(p, "MODE", "%s %s", p->nickname, mode);

      free(mode);
    }

    /* Send detach message to all channels we're on */
    if ((p->server_status == IRC_SERVER_ACTIVE)
        && (p->client_status == IRC_CLIENT_ACTIVE)) {
      if (p->conn_class->detach_message) {
        struct ircchannel *c;
        int slashme;
        char *msg;

        msg = p->conn_class->detach_message;
        if ((strlen(msg) >= 5) && !strncasecmp(msg, "/me ", 4)) {
          /* Starts with /me */
          slashme = 1;
          msg += 4;
        } else {
          slashme = 0;
        }

        c = p->channels;
        while (c) {
          if (!c->inactive && !c->unjoined) {
            if (slashme) {
              ircserver_send_command(p, "PRIVMSG", "%s :\001ACTION %s\001",
                                     c->name, msg);
            } else {
              ircserver_send_command(p, "PRIVMSG", "%s :%s", c->name, msg);
            }
          }
          c = c->next;
        }
      }
    }

    /* Leave channels until they come back */
    if ((p->server_status == IRC_SERVER_ACTIVE)
        && (p->client_status == IRC_CLIENT_ACTIVE)) {
      if (p->conn_class->channel_leave_on_detach) {
        struct ircchannel *c;

        c = p->channels;
        while (c) {
          struct ircchannel *t;

          t = c;
          c = c->next;

          /* Leave the channel and decide whether to delete it or rejoin */
          if (!t->inactive && !t->unjoined) {
            ircserver_send_command(p, "PART", ":%s", t->name);
            if (p->conn_class->channel_rejoin_on_attach) {
              t->unjoined = 1;
            } else {
              ircnet_delchannel(p, t->name);
            }
          }
        }
      }
    }

    /* Set away message */
    if ((p->server_status == IRC_SERVER_ACTIVE)
        && (p->client_status == IRC_CLIENT_ACTIVE)) {
      if (message) {
        ircserver_send_command(p, "AWAY", ":%s", message);
      } else if (!p->awaymessage && p->conn_class->away_message) {
        ircserver_send_command(p, "AWAY", ":%s", p->conn_class->away_message);
      }
    }

    /* Change Nickname */
    if ((p->client_status == IRC_CLIENT_ACTIVE)
        && p->conn_class->detach_nickname) {
      char *nick, *ptr;

      nick = x_strdup(p->conn_class->detach_nickname);
      ptr = strchr(nick, '*');
      if (ptr) {
        char *newnick;

        *(ptr++) = 0;
        newnick = x_sprintf("%s%s%s", nick, p->nickname, ptr);
        free(nick);
        nick = newnick;
      }
      debug("Auto-nick-change '%s'", nick);

      /* We need to remember what the setnickname is now so when the client
         comes back we can reset it again.  So put it in oldnickname. */
      if (p->oldnickname)
        free(p->oldnickname);
      p->oldnickname = p->setnickname;
      p->setnickname = 0;

      ircclient_change_nick(p, nick);

      free(nick);
    }

    /* Open private_log */
    if ((p->client_status == IRC_CLIENT_ACTIVE)
        && p->conn_class->private_log_enabled
        && !p->conn_class->private_log_always) {
      if (irclog_open(p, p->nickname))
        ircclient_send_notice(p, "(warning) Unable to log private messages");
    }

    /* Open server log */
    if ((p->client_status == IRC_CLIENT_ACTIVE)
        && p->conn_class->server_log_enabled
        && !p->conn_class->server_log_always) {
      if (irclog_open(p, 0))
        ircclient_send_notice(p, "(warning) Unable to log server messages");
    }

    /* Open channel logs */
    if ((p->client_status == IRC_CLIENT_ACTIVE)
        && p->conn_class->chan_log_enabled
        && !p->conn_class->chan_log_always) {
      struct ircchannel *c;

      c = p->channels;
      while (c) {
        if (irclog_open(p, c->name))
          ircclient_send_notice(p, "(warning) Unable to log channel: %s",
                                c->name);
        c = c->next;
      }
    }

    /* Close the socket */
    ircclient_close(p);
  }

  return 0;
}

/* Called when we get an irc protocol data from a client */
static int _ircclient_gotmsg(struct ircproxy *p, const char *str) {
  struct ircmessage msg;

  if (ircprot_parsemsg(str, &msg) == -1)
    return -1;

  debug("c=%02x, s=%02x", p->client_status, p->server_status);

  if (!(p->client_status & IRC_CLIENT_AUTHED)) {
    /* Accept PASS, NICK and USER commands only until we've authenticated */
    if (!irc_strcasecmp(msg.cmd, "PASS")) {
      if (msg.numparams >= 1) {
        if (p->password)
          free(p->password);
        p->password = x_strdup(msg.params[0]);
        p->client_status |= IRC_CLIENT_GOTPASS;
      } else {
        ircclient_send_numeric(p, 461, ":Not enough parameters");
      }

    } else if (!irc_strcasecmp(msg.cmd, "NICK")) {
      if (msg.numparams >= 1) {
        if (!(p->client_status & IRC_CLIENT_GOTNICK)
            || strcmp(p->nickname, msg.params[0]))
          ircclient_change_nick(p, msg.params[0]);
      } else {
        ircclient_send_numeric(p, 431, ":No nickname given");
      }

    } else if (!irc_strcasecmp(msg.cmd, "USER")) {
      if (msg.numparams >= 4) {
        if (!(p->client_status & IRC_CLIENT_GOTUSER))
          _ircclient_got_details(p, msg.params[0], msg.params[1],
                                 msg.params[2], msg.params[3]);
      } else {
        ircclient_send_numeric(p, 461, ":Not enough parameters");
      }

    } else if (!(p->client_status & IRC_CLIENT_GOTPASS)) {
      ircclient_send_notice(p, "Please send /QUOTE PASS <password> to login");

    } else {
      ircclient_send_notice(p, "Please send /QUOTE NICK and /QUOTE USER");
    }

  } else if (!(p->client_status & IRC_CLIENT_GOTNICK)) {
    /* We've lost the nickname */
    if (!irc_strcasecmp(msg.cmd, "NICK")) {
      if (msg.numparams >= 1) {
        ircclient_change_nick(p, msg.params[0]);
      } else {
        ircclient_send_numeric(p, 431, ":No nickname given");
      }

    } else {
      ircclient_send_notice(p, "Please send a /NICK command");
    }

  } else {
    /* The server MUST be active to use most of the commands.  The only
       exception is /DIRCPROXY. */

    if (p->server_status == IRC_SERVER_ACTIVE) {
      /* By default we squelch everything, but the else clause turns this off.
         Effectively it means that all handled commands are not passed to the
         server unless you set squelch to 0 */
      int squelch = 1;

      if (!irc_strcasecmp(msg.cmd, "PASS")) {
        /* Ignore PASS */
      } else if (!irc_strcasecmp(msg.cmd, "USER")) {
        /* Ignore USER */
      } else if (!irc_strcasecmp(msg.cmd, "DIRCPROXY")) {
        /* Ignore DIRCPROXY (handled in a minute) */
      } else if (!irc_strcasecmp(msg.cmd, "QUIT")) {
        /* User wants to detach */
        ircnet_announce_status(p);
        ircclient_send_error(p, "Detached from %s %s", PACKAGE, VERSION);
        _ircclient_detach(p, 0);
        ircprot_freemsg(&msg);
        return 0;

      } else if (!irc_strcasecmp(msg.cmd, "PONG")) {
        /* Ignore PONG */

      } else if (!irc_strcasecmp(msg.cmd, "NICK")) {
        /* User changing their nickname */
        if (msg.numparams >= 1) {
          ircclient_change_nick(p, msg.params[0]);
        } else {
          ircclient_send_numeric(p, 431, ":No nickname given");
        }

      } else if (!irc_strcasecmp(msg.cmd, "AWAY")) {
        /* User marking themselves as away or back */
        squelch = 0;

        /* ircII sends an empty parameter to mark back *grr* */
        if ((msg.numparams >= 1) && strlen(msg.params[0])) {
          free(p->awaymessage);
          p->awaymessage = x_strdup(msg.params[0]);
        } else {
          free(p->awaymessage);
          p->awaymessage = 0;
        }

      } else if (!irc_strcasecmp(msg.cmd, "MOTD")) {
        /* User requesting the message of the day from the server */
        p->allow_motd = 1;
        squelch = 0;

      } else if (!irc_strcasecmp(msg.cmd, "PING")) {
        /* User requesting a ping from the server */
        p->allow_pong = 1;
        squelch = 0;

      } else if (!irc_strcasecmp(msg.cmd, "PRIVMSG")) {
        /* All PRIVMSGs go to the server unless we fiddle */
        squelch = _ircclient_handle_privmsg(p, msg);

      } else if (!irc_strcasecmp(msg.cmd, "NOTICE")) {
        /* Notices from us get logged */
        if (msg.numparams >= 2) {
          char *str;

          ircprot_stripctcp(msg.params[1], &str, 0);

          if (str && strlen(str)) {
            char *tmp;

            tmp = x_sprintf("%s!%s@%s", p->nickname, p->username,
                            p->hostname);
            irclog_log(p, IRC_LOG_NOTICE, msg.params[0], tmp, "%s", str);
            free(tmp);
          }
          free(str);
        }

        if (p->conn_class->idle_maxtime)
          ircserver_resetidle(p);
        squelch = 0;

      } else {
        squelch = 0;
      }

      /* Send command up to server? (We know there is one at this point) */
      if (!squelch)
        net_send(p->server_sock, "%s\r\n", msg.orig);

    } else if (irc_strcasecmp(msg.cmd, "DIRCPROXY")) {
      /* Command didn't (and won't be) handled.  We better stick to the
         RFC and send a RPL_TRYAGAIN back. */
      ircclient_send_numeric(p, 263, "%s :Please wait a while and try again.",
                             msg.cmd);
    }

    /* /DIRCPROXY can be used at *any* time, if it ever sends anything to the
       server it has to do it explicitly (no automatic sending) and has to
       check there is a server there */
    if (!irc_strcasecmp(msg.cmd, "DIRCPROXY")) {
      if (msg.numparams >= 1) {
        if (!irc_strcasecmp(msg.params[0], "RECALL")) {
          _ircclient_handle_recall(p, msg);

        } else if (p->conn_class->allow_persist
                   && !irc_strcasecmp(msg.params[0], "PERSIST")) {
          /* User wants a die_on_close proxy to persist */
          if (p->die_on_close) {
            if (p->conn_class->disconnect_on_detach) {
              /* Its die_on_close because of configuration, can't dedicate! */
              p->die_on_close = 0;
              ircnet_announce_dedicated(p);
            } else if (!ircnet_dedicate(p)) {
              /* Okay, it was inetd - we can dedicate this */
              p->die_on_close = 0;
            } else {
              ircclient_send_notice(p, "Could not persist");
            }
          } else {
            ircnet_announce_dedicated(p);
          }

        } else if (!irc_strcasecmp(msg.params[0], "RELOAD")) {
          /* User wants to reload the configuration file */
          ircclient_send_notice(p, "RELOAD in progress");
          reload();

        } else if (!irc_strcasecmp(msg.params[0], "DETACH")) {
          /* User wants to detach and can't be bothered to use /QUIT */
          ircnet_announce_status(p);
          ircclient_send_error(p, "Detached from %s %s", PACKAGE, VERSION);

          /* Optional AWAY message can be supplied */
          if ((msg.numparams >= 2) && strlen(msg.paramstarts[1])) {
            _ircclient_detach(p, msg.paramstarts[1]);
          } else {
            _ircclient_detach(p, 0);
          }
          ircprot_freemsg(&msg);
          return 0;

        } else if (!irc_strcasecmp(msg.params[0], "QUIT")) {
          /* User wants to detach and end their proxy session */

          if (IS_SERVER_READY(p)) {
            /* Optional QUIT message can be supplied */
            if ((msg.numparams >= 2) && strlen(msg.paramstarts[1])) {
              ircserver_send_command(p, "QUIT", ":%s", msg.paramstarts[1]);
            } else if (p->conn_class->quit_message) {
              ircserver_send_command(p, "QUIT", ":%s",
                                     p->conn_class->quit_message);
            } else {
              ircserver_send_command(p, "QUIT", ":Leaving IRC - %s %s",
                                     PACKAGE, VERSION);
            }
          }

          ircserver_close_sock(p);
          p->conn_class = 0;
          ircclient_close(p);
          ircprot_freemsg(&msg);
          return 0;

        } else if (!irc_strcasecmp(msg.params[0], "MOTD")) {
          /* Display message of the day file */
          _ircclient_motd(p);

        } else if (p->conn_class->allow_die
                   && !irc_strcasecmp(msg.params[0], "DIE")) {
          /* User wants to kill us :( */
          ircclient_send_notice(p, "I'm melting!");
          stop();

        } else if (p->conn_class->allow_users
                   && !irc_strcasecmp(msg.params[0], "USERS")) {
					_ircclient_handle_users(p, msg);

        } else if (p->conn_class->allow_kill
                   && !irc_strcasecmp(msg.params[0], "KILL")) {
          _ircclient_handle_kill(p, msg);
	   
	} else if (p->conn_class->allow_notify
		   && !irc_strcasecmp(msg.params[0], "NOTIFY")) {
	  _ircclient_handle_notify(p, msg);
	      
        } else if (!irc_strcasecmp(msg.params[0], "SERVERS")) {
          struct strlist *s;
          int i;

          s = p->conn_class->servers;
          i = 0;

          /* User wants a server list */
          if (s) {
            ircclient_send_notice(p, "You can connect to:");
          } else {
            ircclient_send_notice(p, "No servers");
          }

          while (s) {
            ircclient_send_notice(p, "-%s %2d. %s",
                                  (s == p->conn_class->next_server ? ">" : " "),
                                  ++i, s->str);
            s = s->next;
          }

        } else if (p->conn_class->allow_jump
                   && (!irc_strcasecmp(msg.params[0], "JUMP")
                       || !irc_strcasecmp(msg.params[0], "CONNECT"))) {
          if (_ircclient_handle_jump(p, msg))
            return 0;

        } else if (p->conn_class->allow_host
                   && !irc_strcasecmp(msg.params[0], "HOST")) {
          /* User wants to change their hostname */
          free(p->conn_class->local_address);
          p->conn_class->local_address = 0;

          if (msg.numparams >= 2) {
            if (irc_strcasecmp(msg.params[1], "none"))
              p->conn_class->local_address = x_strdup(msg.params[1]);

          } else if (p->conn_class->orig_local_address) {
            p->conn_class->local_address =
                x_strdup(p->conn_class->orig_local_address);
          }

          ircserver_connectagain(p);

          /* We have no server now, so need to get out of here */
          ircprot_freemsg(&msg);
          return 0;

        } else if (!irc_strcasecmp(msg.params[0], "STATUS")) {
          _ircclient_handle_status(p, msg);

        } else if (!irc_strcasecmp(msg.params[0], "HELP")) {
          /* User needs a little help */
          _ircclient_handle_help(p, msg);

        } else {
          /* Invalid command */
          ircclient_send_numeric(p, 421, "%s :Unknown DIRCPROXY command",
                                 msg.params[0]);

        }
      } else {
        ircclient_send_numeric(p, 461, ":Not enough parameters");
      }
    }
  }

  /* Do we have enough information to authenticate them? */
  if (!(p->client_status & IRC_CLIENT_AUTHED)
      && (p->client_status & IRC_CLIENT_GOTPASS)
      && (p->client_status & IRC_CLIENT_GOTNICK)
      && (p->client_status & IRC_CLIENT_GOTUSER))
  {
    _ircclient_authenticate(p, p->password);
    free(p->password);
    p->password = 0;
    p->client_status &= ~(IRC_CLIENT_GOTPASS);
  }

  /* Do we have enough information to connect to a server? */
  if (IS_CLIENT_READY(p) && !p->dead) {
    if (p->server_status != IRC_SERVER_ACTIVE) {
      if (!(p->server_status & IRC_SERVER_CREATED)) {
        if (p->conn_class && p->conn_class->server_autoconnect) {
          ircserver_connect(p);
        } else {
          ircclient_send_notice(p, "Please send /DIRCPROXY JUMP "
                                "<hostname>[:[port][:[password]]] to choose a "
                                "server");

          /* This won't delete an existing timer */
          timer_new((void *)p, "client_connect", g.connect_timeout,
                    TIMER_FUNCTION(_ircclient_timedout), (void *)1);
        }
      } else if (!IS_SERVER_READY(p)) {
        ircclient_send_notice(p, "Connection to server is in progress...");
      }
    } else if (!(p->client_status & IRC_CLIENT_SENTWELCOME)) {
      ircclient_welcome(p);
    }
  }

  ircprot_freemsg(&msg);
  return 0;
}

/* Got a password */
static int _ircclient_authenticate(struct ircproxy *p, const char *password) {
  struct ircconnclass *cc;

  cc = connclasses;
  while (cc) {
#ifdef ENCRYPTED_PASSWORDS
    char *cmp;

    cmp = crypt(password, cc->password);

    if (!strcmp(cc->password, cmp)) {
#else
    if (!strcmp(cc->password, password)) {
#endif
      if (cc->masklist) {
        struct strlist *m;
        const char *ip;
        char buf[40];

        ip = net_ntop(&p->client_addr, buf, sizeof(buf));

        m = cc->masklist;
        while (m) {
          if (strcasematch(ip, m->str) || strcasematch(p->client_host, m->str))
            break;

          m = m->next;
        }

        /* We got a matching masklist, so this one's ok */
        if (m)
          break;
      } else {
        break;
      }
    }

    cc = cc->next;
  }

  if (cc) {
    struct ircproxy *tmp_p;

    tmp_p = ircnet_fetchclass(cc);
    if (tmp_p && (tmp_p->client_status & IRC_CLIENT_CONNECTED)) {
      if (tmp_p->conn_class->disconnect_existing) {
        debug("Already connected, disconnecting existing");

        ircclient_send_error(tmp_p, "Collided with new user");
        ircclient_close(tmp_p);

        if (tmp_p->dead) {
          debug("Kicked off client, and they died");
          tmp_p = 0;
        }
      } else {
        debug("Already connected, disconnecting incoming");
        ircclient_send_error(p, "Already connected");
        ircclient_close(p);
        return -1;
      }
    }

    /* Check again, in case killing existing user killed the proxy */
    if (tmp_p) {
      debug("Attaching new client to old server session");

      tmp_p->client_sock = p->client_sock;
      tmp_p->client_status |= IRC_CLIENT_CONNECTED | IRC_CLIENT_AUTHED;
      tmp_p->client_addr = p->client_addr;
      net_hook(tmp_p->client_sock, SOCK_NORMAL, (void *)tmp_p,
               ACTIVITY_FUNCTION(_ircclient_data),
               ERROR_FUNCTION(_ircclient_error));

      /* If the connecting client doesn't agree with the proxy about its
         nickname, then correct it. */
      if (strcmp(p->nickname, tmp_p->nickname))
        ircclient_send_selfcmd(p, "NICK", ":%s", tmp_p->nickname);

      /* If we've got to restore a different nickname, then do that now */
      if (tmp_p->oldnickname && strcmp(tmp_p->oldnickname, tmp_p->nickname))
        ircclient_change_nick(tmp_p, tmp_p->oldnickname);

      /* We don't need this anymore */
      free(tmp_p->oldnickname);
      tmp_p->oldnickname = 0;

      /* Notify nickserv */
      if (tmp_p->conn_class->nickserv_password)
	 ircserver_send_command(tmp_p, "PRIVMSG", " %s :IDENTIFY %s", "NICKSERV",tmp_p->conn_class->nickserv_password);

      /* Unset any away message if we set one */
      if (!tmp_p->awaymessage && (tmp_p->server_status == IRC_SERVER_ACTIVE)
          && tmp_p->conn_class->away_message)
        ircserver_send_command(tmp_p, "AWAY", "");

      /* Rejoin any channels we parted */
      if ((tmp_p->server_status == IRC_SERVER_ACTIVE) && tmp_p->channels) {
        struct ircchannel *c;

        c = tmp_p->channels;
        while (c) {
          if (c->unjoined) {
            if (c->key) {
              ircserver_send_command(tmp_p, "JOIN", "%s :%s", c->name, c->key);
            } else {
              ircserver_send_command(tmp_p, "JOIN", ":%s", c->name);
            }
          }

          c = c->next;
        }
      }

      /* Send attach message to all channels we're on */
      if (tmp_p->server_status == IRC_SERVER_ACTIVE) {
        if (tmp_p->conn_class->attach_message) {
          struct ircchannel *c;
          int slashme;
          char *msg;

          msg = tmp_p->conn_class->attach_message;
          if ((strlen(msg) >= 5) && !strncasecmp(msg, "/me ", 4)) {
            /* Starts with /me */
            slashme = 1;
            msg += 4;
          } else {
            slashme = 0;
          }

          c = tmp_p->channels;
          while (c) {
            if (!c->inactive) {
              if (slashme) {
                ircserver_send_command(tmp_p, "PRIVMSG",
                                       "%s :\001ACTION %s\001", c->name, msg);
              } else {
                ircserver_send_command(tmp_p, "PRIVMSG", "%s :%s",
                                       c->name, msg);
              }
            }
            c = c->next;
          }
        }
      }

      if ((tmp_p->server_status == IRC_SERVER_ACTIVE)
          && !(tmp_p->client_status & IRC_CLIENT_SENTWELCOME))
        ircclient_welcome(tmp_p);

      p->client_status = IRC_CLIENT_NONE;
      p->client_sock = -1;
      p->dead = 1;

    } else {
      struct strlist *s;

      p->conn_class = cc;
      p->client_status |= IRC_CLIENT_AUTHED;
      time(&(p->start));

      if (p->conn_class->disconnect_on_detach)
        p->die_on_close = 1;

      /* Okay, they've authed for the first time, make the log directory
         here */
      if (p->conn_class->chan_log_enabled
          || p->conn_class->private_log_enabled
          || p->conn_class->server_log_enabled) {
        if (irclog_maketempdir(p))
          ircclient_send_notice(p, "(warning) Unable to create log "
                                   "directory, logging disabled");
      }

      /* Initialise the private message log */
      irclog_init(p, "");

      /* Open a log file if we're always logging */
      if (p->conn_class->private_log_enabled
          && p->conn_class->private_log_always) {
        if (irclog_open(p, ""))
          ircclient_send_notice(p, "(warning) Unable to log private messages");
      }

      /* Initialise the server message log */
      irclog_init(p, 0);

      /* Open a log file if we're always logging */
      if (p->conn_class->server_log_enabled
          && p->conn_class->server_log_always) {
        if (irclog_open(p, 0))
          ircclient_send_notice(p, "(warning) Unable to log server messages");
      }

      /* Join initial channels */
      s = p->conn_class->channels;
      while (s) {
        struct ircchannel *c;
        char *name, *key;

        name = x_strdup(s->str);
        key = strchr(name, ' ');
        if (key)
          *(key++) = 0;

        ircnet_addchannel(p, name);
        c = ircnet_fetchchannel(p, name);
        if (c) {
          c->inactive = 1;
          if (key)
            c->key = x_strdup(key);
        }

        free(name);

        s = s->next;
      }

      /* Set initial modes */
      if (p->conn_class->initial_modes)
        ircclient_change_mode(p, p->conn_class->initial_modes);

      /* Notify nickserv */
      // currently broken i will look in next revision
      /* if (p->conn_class->nickserv_password) */
      /* ircserver_send_command(p, "PRIVMSG", " %s :IDENTIFY %s", "NICKSERV",p->conn_class->nickserv_password); */
    }

    return 0;
  }

  ircclient_send_numeric(p, 464, ":You are not permitted to use this proxy");
  ircclient_send_error(p, "Permission Denied");
  ircclient_close(p);
  return -1;
}

/* Request a nickname change */
int ircclient_change_nick(struct ircproxy *p, const char *newnick) {
  /* If a server is ready to accept a NICK command, send it */
  if (IS_SERVER_READY(p)) {
    debug("Requesting nick change from '%s' to '%s'",
          (p->nickname ? p->nickname : ""), newnick);
    ircserver_send_command(p, "NICK", ":%s", newnick);
  }

  /* If we have a nickname already then the server will confirm that, otherwise
     we should remember it ourselves */
  if (p->client_status & IRC_CLIENT_GOTNICK) {
    debug("Server will change it for us");
    p->expecting_nick = 1;

    return 0;
  } else {
    int ret;

    /* Because we're not expecting a server confirmation, then we better
       do the confirm for the client ourselves */
    if ((p->client_status & IRC_CLIENT_CONNECTED) &&
        (p->client_status & IRC_CLIENT_AUTHED))
      ircclient_send_selfcmd(p, "NICK", ":%s", newnick);

    /* Make the change in the wings */
    ret = ircclient_nick_changed(p, newnick);
    ircclient_setnickname(p);
    ircclient_checknickname(p);

    return ret;
  }
}

/* Nickname has now definitly been changed */
int ircclient_nick_changed(struct ircproxy *p, const char *newnick) {
  if (p->nickname)
    debug("nickname WAS '%s'", p->nickname);
  free(p->nickname);

  p->nickname = x_strdup(newnick);
  p->client_status |= IRC_CLIENT_GOTNICK;
  debug("nickname NOW '%s'", p->nickname);

  return 0;
}

/* Make the current nickname the set one */
int ircclient_setnickname(struct ircproxy *p) {
  /* Update setnickname too */
  if (p->setnickname)
    free(p->setnickname);
  p->setnickname = x_strdup(p->nickname);
  debug("Changed setnickname to '%s'", p->setnickname);

  return 0;
}

/* Check whether we need to restore the nickname later */
int ircclient_checknickname(struct ircproxy *p) {
  if (p->conn_class && p->conn_class->nick_keep
      && strcmp(p->nickname, p->setnickname))
    timer_new((void *)p, "client_resetnick", NICK_GUARD_TIME,
              TIMER_FUNCTION(_ircclient_resetnick), (void *)0);

  return 0;
}

/* Change the nickname to something we generate ourselves */
int ircclient_generate_nick(struct ircproxy *p, const char *tried) {
  char *c, *nick;
  int ret;

  c = nick = (char *)malloc(strlen(tried) + 2);
  strcpy(nick, tried);
  c += strlen(nick) - 1;

  /* We add -'s until we can't, then we move back through them cycling them
     0..9 then finally _ until the whole nickname is _________.  Once that
     happens we just use 'dircproxy' and do it all over again */
  if (strlen(nick) < 9) {
    *(++c) = '-';
    *(++c) = 0;
  } else {
    while (c >= nick) {
      if (*c == '-') {
        *c = '0';
        break;
      } else if ((*c >= '0') && (*c < '9')) {
        (*c)++;
        break;
      } else if (*c == '9') {
        *c = '_';
        break;
      } else if (*c == '_') {
        c--;
      } else {
        *c = '-';
        break;
      }
    }

    if (c < nick) {
      free(nick);
      nick = x_strdup(FALLBACK_NICKNAME);
    }
  }

  /* Ask the server to change the nickname */
  if (IS_SERVER_READY(p)) {
    debug("Requesting nick change from '%s' to '%s'",
          (p->nickname ? p->nickname : ""), nick);
    ircserver_send_command(p, "NICK", ":%s", nick);
  }

  /* If we don't have a nickname yet, make the change ourselves */
  if (!(p->client_status & IRC_CLIENT_GOTNICK)) {
    /* We know that there is no client connected, otherwise this would
       never have been called, so no point sending a nickname to the client.

       Just change it in our memory */
    ret = ircclient_nick_changed(p, nick);
    ircclient_checknickname(p);
  } else {
    debug("Server will change it for us");
  }

  free(nick);
  return 0;
}

/* Timer hook to restore a lost nickname */
static void _ircclient_resetnick(struct ircproxy *p, void *data) {
  /* We don't have a server anymore, setnickname will be restored on
     connection attempt */
  if (!IS_SERVER_READY(p))
    return;

  /* Is it worth doing this? */
  if (!strcmp(p->nickname, p->setnickname))
    return;

  /* Ask the server to change the nickname */
  debug("Attempting to restore nickname to '%s'", p->setnickname);
  ircclient_change_nick(p, p->setnickname);
}

/* Got some details */
static int _ircclient_got_details(struct ircproxy *p, const char *newusername,
                                  const char *newmode, const char *unused,
                                  const char *newrealname) {
  int mode;

  if (!p->username)
    p->username = x_strdup(newusername);

  if (!p->realname)
    p->realname = x_strdup(newrealname);

  /* RFC2812 states that the second parameter to USER is a numeric stating
     what default modes to set.  This disagrees with RFC1459.  We follow
     the newer one if we can, as the old hostname/servername combo were
     useless and ignored anyway. */
  mode = atoi(newmode);
  if (mode & RFC2812_MODE_W)
    ircclient_change_mode(p, "+w");
  if (mode & RFC2812_MODE_I)
    ircclient_change_mode(p, "+w");

  /* Okay we have the username now */
  p->client_status |= IRC_CLIENT_GOTUSER;

  return 0;
}

/* Got a personal mode change */
int ircclient_change_mode(struct ircproxy *p, const char *change) {
  char *ptr, *str;
  int add = 1;

  ptr = str = x_strdup(change);
  debug("Mode change from '%s', '%s'", (p->modes ? p->modes : ""), str);

  while (*ptr) {
    switch (*ptr) {
      case '+':
        add = 1;
        break;
      case '-':
        add = 0;
        break;
      default:
        if (add) {
          if (!p->modes || !strchr(p->modes, *ptr)) {
            if (p->modes) {
              p->modes = (char *)realloc(p->modes, strlen(p->modes) + 2);
            } else {
              p->modes = (char *)malloc(2);
              p->modes[0] = 0;
            }
            p->modes[strlen(p->modes) + 1] = 0;
            p->modes[strlen(p->modes)] = *ptr;
          }
        } else if (p->modes) {
          char *pos;

          pos = strchr(p->modes, *ptr);
          if (pos) {
            char *tmp;

            tmp = p->modes;
            p->modes = (char *)malloc(strlen(p->modes));
            *(pos++) = 0;
            strcpy(p->modes, tmp);
            strcpy(p->modes + strlen(p->modes), pos);
            free(tmp);

            if (!strlen(p->modes)) {
              free(p->modes);
              p->modes = 0;
            }
          }
        }
    }

    ptr++;
  }

  debug("    now '%s'", (p->modes ? p->modes : ""));
  free(str);
  return 0;
}

/* Close the client socket */
int ircclient_close(struct ircproxy *p) {
  timer_del((void *)p, "client_auth");
  timer_del((void *)p, "client_connect");

  net_close(&(p->client_sock));
  p->client_sock = -1;
  p->client_status &= ~(IRC_CLIENT_CONNECTED | IRC_CLIENT_AUTHED
                        | IRC_CLIENT_SENTWELCOME);

  /* No connection class, or no nick or user? Die! */
  if (!p->conn_class || !(p->client_status & IRC_CLIENT_GOTNICK)
      || !(p->client_status & IRC_CLIENT_GOTUSER)) {
    if (p->server_status & IRC_SERVER_CREATED) {
      ircserver_send_command(p, "QUIT", ":I shouldn't really be here - %s %s",
                             PACKAGE, VERSION);
      ircserver_close_sock(p);
    }
    p->dead = 1;
  }

  return p->dead;
}

/* send message of the day to the user */
static int _ircclient_motd(struct ircproxy *p) {
  FILE *motd_file;

  if (p->conn_class->motd_file) {
    motd_file = fopen(p->conn_class->motd_file, "r");
    if (!motd_file)
      syscall_fail("fopen", p->conn_class->motd_file, 0);
  } else {
    motd_file = (FILE *)0;
  }

  /* Check whether to do anything, and send appropriate numerics */
  if (!p->conn_class->motd_logo && !p->conn_class->motd_stats && !motd_file) {
    if (p->conn_class->motd_file) {
      ircclient_send_numeric(p, 422, ":MOTD File is missing");
    } else {
      ircclient_send_numeric(p, 422, ":No MOTD");
    }
    return 0;
  } else {
    ircclient_send_numeric(p, 375, ":- %s Message of the Day -", PACKAGE);
  }

  /* Send the pretty dircproxy logo */
  if (p->conn_class->motd_logo) {
    char *ver;
    int line;

    line = 0;
    while (logo[line]) {
      ircclient_send_numeric(p, 372, ":- %s", logo[line]);
      line++;
    }

    ver = x_sprintf(verstr, VERSION);
    ircclient_send_numeric(p, 372, ":- %s", ver);
    ircclient_send_numeric(p, 372, ":-");
    free(ver);
  }

  /* Send from file */
  if (motd_file) {
    char buff[512];

    while (fgets(buff, 512, motd_file)) {
      char *ptr;

      ptr = buff + strlen(buff);
      while ((ptr >= buff) && (!ptr || strchr(" \t\r\n", *ptr))) *(ptr--) = 0;
      ircclient_send_numeric(p, 372, ":- %s", buff);
    }

    ircclient_send_numeric(p, 372, ":-");
  }

  /* Send some stats */
  if (p->conn_class->motd_stats) {
    /* Private messages */
    if (p->private_log.filename) {
      char *s;

      if (p->conn_class->private_log_recall == -1) {
        s = x_strdup(p->private_log.nlines ? "all" : "none");
      } else if (p->conn_class->private_log_recall == 0) {
        s = x_strdup("none");
      } else if (p->conn_class->private_log_recall == p->private_log.nlines) {
        s = x_strdup("all");
      } else {
        s = x_sprintf("%ld", p->conn_class->private_log_recall);
      }

      ircclient_send_numeric(p, 372, ":- %ld private message%s "
                             "(%s will be sent)", p->private_log.nlines,
                             (p->private_log.nlines == 1 ? "" : "s"), s);
      ircclient_send_numeric(p, 372, ":-");

      free(s);
    }

    /* Server messages */
    if (p->server_log.filename) {
      char *s;

      if (p->conn_class->server_log_recall == -1) {
        s = x_strdup(p->server_log.nlines ? "all" : "none");
      } else if (p->conn_class->server_log_recall == 0) {
        s = x_strdup("none");
      } else if (p->conn_class->server_log_recall == p->server_log.nlines) {
        s = x_strdup("all");
      } else {
        s = x_sprintf("%ld", p->conn_class->server_log_recall);
      }

      ircclient_send_numeric(p, 372, ":- %ld server message%s "
                             "(%s will be sent)", p->server_log.nlines,
                             (p->server_log.nlines == 1 ? "" : "s"), s);
      ircclient_send_numeric(p, 372, ":-");

      free(s);
    }


    /* Channels they were on */
    if (p->channels) {
      struct ircchannel *c;

      c = p->channels;
      while (c) {
        if (c->inactive) {
          if (c->log.nlines) {
            ircclient_send_numeric(p, 372, ":- was on %s but removed by force",
                                   c->name);
          } else {
            ircclient_send_numeric(p, 372, ":- yet to join %s", c->name);
          }
        } else if (c->unjoined) {
          ircclient_send_numeric(p, 372, ":- was on %s, yet to rejoin",
                                 c->name);
        } else if (c->log.filename) {
          char *s;

          if (p->conn_class->chan_log_recall == -1) {
            s = x_strdup(c->log.nlines ? "all" : "none");
          } else if (p->conn_class->chan_log_recall == 0) {
            s = x_strdup("none");
          } else if (p->conn_class->chan_log_recall == c->log.nlines) {
            s = x_strdup("all");
          } else {
            s = x_sprintf("%ld", MIN(c->log.nlines,
                                     p->conn_class->chan_log_recall));
          }

          ircclient_send_numeric(p, 372, ":- %s. %ld line%s logged. "
                                 "(%s will be sent)", c->name, c->log.nlines,
                                 (c->log.nlines == 1 ? "" : "s"), s);

          free(s);
        } else {
          ircclient_send_numeric(p, 372, ":- %s (not logged)", c->name);
        }
        c = c->next;
      }
      ircclient_send_numeric(p, 372, ":-");
    }
  }

  /* Done */
  ircclient_send_numeric(p, 376, ":End of /MOTD command");
  if (motd_file)
    fclose(motd_file);

  return 1;
}

/* send welcome headers to the user */
int ircclient_welcome(struct ircproxy *p) {
  char tbuf[40];

  strftime(tbuf, sizeof(tbuf), START_TIMEDATE_FORMAT, localtime(&(p->start)));

  ircclient_send_numeric(p, 1, ":Welcome to the Internet Relay Network %s",
                         p->nickname);
  ircclient_send_numeric(p, 2, ":Your host is %s running %s via %s %s",
                         p->servername,
                         (p->serverver ? p->serverver : "(unknown)"),
                         PACKAGE, VERSION);
  ircclient_send_numeric(p, 3, ":This proxy has been running since %s", tbuf);
  if (p->serverver)
    ircclient_send_numeric(p, 4, "%s %s %s %s",
                           p->servername, p->serverver,
                           p->serverumodes, p->servercmodes);
  struct strlist *s = p->serversupported;
  while (s) {
    ircclient_send_numeric(p, 5, "%s", s->str);
    s = s->next;
  }

  _ircclient_motd(p);

  if (p->modes)
    ircclient_send_selfcmd(p, "MODE", "%s +%s", p->nickname, p->modes);

  if (p->awaymessage) {
    /* Ack.  There's no reason for a client to expect AWAY from a server,
       so we cheat and send a 306, reminding them what their away message
       was in the text.  This might not trick the client either, but hey,
       I can't do anything about that. */
    ircclient_send_numeric(p, 306, ":%s: %s",
                           "You left yourself away.  Your message was",
                           p->awaymessage);
  }

  /* Recall other log file */
  if (p->conn_class->server_log_enabled) {
    irclog_autorecall(p, 0);
    if (!p->conn_class->server_log_always)
      irclog_close(p, 0);
  }

  /* Recall channel log files, and get channel topic and members from server */
  if (p->channels) {
    struct ircchannel *c;

    c = p->channels;
    while (c) {
      if (!c->inactive && !c->unjoined) {
        ircclient_send_selfcmd(p, "JOIN", ":%s", c->name);
        ircserver_send_command(p, "TOPIC", ":%s", c->name);
        ircserver_send_command(p, "NAMES", ":%s", c->name);

        if (p->conn_class->chan_log_enabled) {
          irclog_autorecall(p, c->name);
          if (!p->conn_class->chan_log_always)
            irclog_close(p, c->name);
        }
      }

      c = c->next;
    }
  }

  /* Recall private log file */
  if (p->conn_class->private_log_enabled) {
    irclog_autorecall(p, p->nickname);
    if (!p->conn_class->private_log_always)
      irclog_close(p, p->nickname);
  }

  irclog_log(p, IRC_LOG_CLIENT, IRC_LOGFILE_ALL, PACKAGE, "You connected");
  ircnet_announce_status(p);

  p->client_status |= IRC_CLIENT_SENTWELCOME;
  return 0;
}

/* Timer hook when something's timed out */
static void _ircclient_timedout(struct ircproxy *p, void *data) {
  int connect;

  /* These are always called after the timeout if the client's still
     connected, check the event they were looking for has happened */
  connect = (int)data;
  if (connect && (p->server_status & IRC_SERVER_CREATED)) {
    /* Connecting to server, and a socket has been created to do it */
    debug("Server has been chosen");
    return;
  } else if (!connect && IS_CLIENT_READY(p)) {
    /* Authorization, and client is ready to accept data */
    debug("They are authorized");
    return;
  }

  /* Timeout! */
  debug("Timed out");
  ircclient_send_error(p, "%s Timeout", (connect ? "Connect" : "Login"));
  ircclient_close(p);
}

/* send a numeric to the user */
int ircclient_send_numeric(struct ircproxy *p, short numeric,
                           const char *format, ...) {
  va_list ap;
  char *msg;
  int ret;

  va_start(ap, format);
  msg = x_vsprintf(format, ap);
  va_end(ap);

  ret = net_send(p->client_sock, ":%s %03d %s %s\r\n",
                 (p->servername ? p->servername : PACKAGE), numeric,
                 (p->nickname ? p->nickname : "*"), msg);
  debug("<- ':%s %03d %s %s'", (p->servername ? p->servername : PACKAGE),
        numeric, (p->nickname ? p->nickname : "*"), msg);

  free(msg);
  return ret;
}

/* send a notice to the user */
int ircclient_send_notice(struct ircproxy *p, const char *format, ...) {
  va_list ap;
  char *msg;
  int ret;

  va_start(ap, format);
  msg = x_vsprintf(format, ap);
  va_end(ap);

  ret = net_send(p->client_sock, ":%s %s %s :%s\r\n", PACKAGE, "NOTICE",
                 (p->nickname ? p->nickname : "AUTH"), msg);
  debug("<- ':%s %s %s :%s'", PACKAGE, "NOTICE",
        (p->nickname ? p->nickname : "AUTH"), msg);

  free(msg);
  return ret;
}

/* send a notice to a channel */
int ircclient_send_channotice(struct ircproxy *p, const char *channel,
                              const char *format, ...) {
  va_list ap;
  char *msg;
  int ret;

  va_start(ap, format);
  msg = x_vsprintf(format, ap);
  va_end(ap);

  ret = net_send(p->client_sock, ":%s %s %s :%s\r\n",
                 (p->servername ? p->servername : PACKAGE), "NOTICE",
                 channel, msg);
  debug("<- ':%s %s %s :%s'", (p->servername ? p->servername : PACKAGE),
        "NOTICE", channel, msg);

  free(msg);
  return ret;
}

/* send a command to the user from the server */
int ircclient_send_command(struct ircproxy *p, const char *command,
                           const char *format, ...) {
  va_list ap;
  char *msg;
  int ret;

  va_start(ap, format);
  msg = x_vsprintf(format, ap);
  va_end(ap);

  ret = net_send(p->client_sock, ":%s %s %s\r\n",
                 (p->servername ? p->servername : PACKAGE), command, msg);
  debug("<- ':%s %s %s'", (p->servername ? p->servername : PACKAGE),
        command, msg);

  free(msg);
  return ret;
}

/* send a command to the user making it look like its from them */
int ircclient_send_selfcmd(struct ircproxy *p, const char *command,
                           const char *format, ...) {
  char *msg, *prefix;
  va_list ap;
  int ret;

  va_start(ap, format);
  msg = x_vsprintf(format, ap);
  va_end(ap);

  if (p->nickname && p->username && p->hostname) {
    prefix = x_sprintf(":%s!%s@%s ", p->nickname, p->username, p->hostname);
  } else if (p->nickname) {
    prefix = x_sprintf(":%s ", p->nickname);
  } else {
    prefix = (char *)malloc(1);
    prefix[0] = 0;
  }

  ret = net_send(p->client_sock, "%s%s %s\r\n", prefix, command, msg);
  debug("<- '%s%s %s'", prefix, command, msg);

  free(prefix);
  free(msg);
  return ret;
}

/* send an error to the user */
int ircclient_send_error(struct ircproxy *p, const char *format, ...) {
  char *msg, *nick, *user, *host;
  va_list ap;
  int ret;

  va_start(ap, format);
  msg = x_vsprintf(format, ap);
  va_end(ap);

  nick = p->nickname ? p->nickname : "";
  user = p->username ? p->username : "user";
  host = p->hostname ? p->hostname : "host";

  ret = net_send(p->client_sock, "%s :%s: %s[%s@%s] (%s)\r\n",
                 "ERROR", "Closing Link", nick, user, host, msg);
  debug("<- '%s :%s: %s[%s@%s] (%s)'", "ERROR", "Closing Link",
        nick, user, host, msg);

  free(msg);
  return ret;
}

/* Send a DCC reject message */
static int _ircclient_send_dccreject(struct ircproxy *p, const char *msg,
                                     const char *reason) {
  int ret = 1;

  if (p && p->conn_class && p->conn_class->dcc_proxy_sendreject &&
      (p->client_status == IRC_CLIENT_ACTIVE)) {
    if (reason) {
      ret = net_send(p->client_sock, "%s (%s: %s)\001\r\n", msg,
                     PACKAGE, reason);
      debug("<- '%s (%s: %s)\001'", msg, PACKAGE, reason);
    } else {
      ret = net_send(p->client_sock, "%s\001\r\n", msg);
      debug("<- '%s\001'", msg);
    }
  }

  return ret;
}

  /* /DIRCPROXY STATUS handler */
void _ircclient_handle_status(struct ircproxy *p, struct ircmessage msg) {
  struct ircchannel *c;
  struct strlist *s;

  ircclient_send_notice(p, "%s %s status:", PACKAGE, VERSION);
  ircclient_send_notice(p, "- Nickname on server: %s", p->nickname);
  ircclient_send_notice(p, "- Nickname to guard: %s", p->setnickname);
  ircclient_send_notice(p, "- Username for server: %s", p->username);
  ircclient_send_notice(p, "- Hostname for server: %s", p->hostname);
  ircclient_send_notice(p, "- Real name for server: %s", p->realname);
  ircclient_send_notice(p, "-");

  ircclient_send_notice(p, "- Client status: %s",
                        IS_CLIENT_READY(p) ? "Ready" : "");
  if (p->client_status != IRC_CLIENT_ACTIVE) {
    if (p->client_status & IRC_CLIENT_CONNECTED)
      ircclient_send_notice(p, "-   Connected");
    if (p->client_status & IRC_CLIENT_GOTPASS)
      ircclient_send_notice(p, "-   Received password");
    if (p->client_status & IRC_CLIENT_GOTNICK)
      ircclient_send_notice(p, "-   Received nickname");
    if (p->client_status & IRC_CLIENT_GOTUSER)
      ircclient_send_notice(p, "-   Received user information");
    if (p->client_status & IRC_CLIENT_AUTHED)
      ircclient_send_notice(p, "-   Authorised");
    if (p->client_status & IRC_CLIENT_SENTWELCOME)
      ircclient_send_notice(p, "-   Welcomed");
  }
  ircclient_send_notice(p, "-");

  ircclient_send_notice(p, "- Server status: %s",
                        IS_SERVER_READY(p) ? "Ready" : "");
  if (p->server_status != IRC_SERVER_ACTIVE) {
    if (p->server_status & IRC_SERVER_CREATED)
      ircclient_send_notice(p, "-   Created");
    if (p->server_status & IRC_SERVER_SEEN)
      ircclient_send_notice(p, "-   Seen");
    if (p->server_status & IRC_SERVER_CONNECTED)
      ircclient_send_notice(p, "-   Connected");
    if (p->server_status & IRC_SERVER_INTRODUCED)
      ircclient_send_notice(p, "-   Introduced ourselves");
    if (p->server_status & IRC_SERVER_GOTWELCOME)
      ircclient_send_notice(p, "-   Have been welcomed");
  }
  ircclient_send_notice(p, "-");

  ircclient_send_notice(p,  "- Servers.  Current marked by '->'");
  s = p->conn_class->servers;
  while (s) {
    ircclient_send_notice(p, "-%s  %s",
                          (s == p->conn_class->next_server ? ">" : " "),
                          s->str);
    s = s->next;
  }
  ircclient_send_notice(p, "-");

  ircclient_send_notice(p, "- Channels");
  c = p->channels;
  while (c) {
    ircclient_send_notice(p, "-   %s%s%s%s%s%s",
                          c->name,
                          c->key ? " (key: " : "",
                          c->key ? c->key : "",
                          c->key ? ")" : "",
                          c->inactive ? " (removed by force)" : "",
                          c->unjoined ? " (left on detach)" : "");
    c = c->next;
  }
  ircclient_send_notice(p, "-");

  ircclient_send_notice(p, "- Advanced:");
  ircclient_send_notice(p, "-   Allow MOTD count: %d", p->allow_motd);
  ircclient_send_notice(p, "-   Allow PONG count: %d", p->allow_pong);
  ircclient_send_notice(p, "-   411 Squelch count: %d", p->squelch_411);
  ircclient_send_notice(p, "-   Expecting NICK count: %d",
                        p->expecting_nick);

  if (p->squelch_modes)
    ircclient_send_notice(p, "-   Squelching mode changes:");
  s = p->squelch_modes;
  while (s) {
    ircclient_send_notice(p, "-     %s", s->str);
    s = s->next;
  }
}

  /* /DIRCPROXY JUMP handler */
int _ircclient_handle_jump(struct ircproxy *p, struct ircmessage msg) {
  struct strlist *server;

  /* User wants to jump to a new server */
  if (msg.numparams >= 2) {
    struct strlist *s;
    int i;

    /* Check the server list to see whether its a plain jump */
    server = 0;
    s = p->conn_class->servers;
    i = 0;
    while (s) {
      if ((atoi(msg.params[1]) == ++i)
          || !irc_strcasecmp(msg.params[1], s->str)) {
        server = s;
        break;
      }

      s = s->next;
    }

  } else {
    /* User wants to jump to the next server */
    server = 0;
    if (p->conn_class->next_server)
      server = p->conn_class->next_server->next;
    if (!server)
      server = p->conn_class->servers;
  }

  /* Allocate new server if jump_new */
  if (!server && p->conn_class->allow_jump_new
      && (msg.numparams >= 2)) {
    debug("New server");

    server = (struct strlist *)malloc(sizeof(struct strlist));
    server->str = x_strdup(msg.params[1]);
    server->next = 0;

    if (p->conn_class->servers) {
      struct strlist *ss;

      ss = p->conn_class->servers;
      while (ss->next)
        ss = ss->next;

      ss->next = server;
    } else {
      p->conn_class->servers = server;
    }

  } else if (!server) {
    ircclient_send_numeric(p, 402, "No such server, "
                           "use /DIRCPROXY SERVERS to see them");
  }

  if (server) {
    debug("Jumping to %s", server->str);

    p->conn_class->next_server = server;
    ircserver_connectagain(p);

    /* We have no server now, so need to get out of here */
    ircprot_freemsg(&msg);
    return 1;
  } else {
    return 0;
  }
}

  /* /DIRCPROXY KILL handler */
void _ircclient_handle_kill(struct ircproxy *p, struct ircmessage msg) {
  struct ircproxy *proxy;

  /* User wants to kill a user */
  if (msg.numparams >= 2) {
    struct ircconnclass *c;
    struct ircproxy *cp;
    int i;

    /* Check the user list */
    proxy = 0;
    c = connclasses;
    i = 0;
    while (c) {
      cp = ircnet_fetchclass(c);
      if (!cp) {
        c = c->next;
        continue;
      }

      if ((atoi(msg.params[1]) == ++i)
          || (cp->client_host
              && !irc_strcasecmp(msg.params[1], cp->client_host))
          || (cp->servername
              && !irc_strcasecmp(msg.params[1], cp->servername))
          || (cp->nickname
              && !irc_strcasecmp(msg.params[1], cp->nickname))) {
        proxy = cp;
        break;
      }

      c = c->next;
    }

    if (proxy && (proxy == p)) {
      ircclient_send_notice(p, "Use /DIRCPROXY QUIT to kill yourself");
    } else if (proxy) {
      if (IS_SERVER_READY(proxy)) {
        ircserver_send_command(proxy, "QUIT",
                               ":Killed by adminstrator - %s %s",
                               PACKAGE, VERSION);
      }
      if (IS_CLIENT_READY(proxy)) {
        ircclient_send_error(proxy, "Killed by administrator");
      }

      ircserver_close_sock(proxy);
      proxy->conn_class = 0;
      ircclient_close(proxy);

    } else {
      ircclient_send_numeric(p, 401, "No such user, "
                             "use /DIRCPROXY USERS to see them");
    }

  } else {
    ircclient_send_numeric(p, 461, ":Not enough parameters");
  }
}

  /* /DIRCPROXY NOTIFY handler */
void _ircclient_handle_notify(struct ircproxy *p, struct ircmessage msg) 
{   
   struct ircproxy *proxy;
   /* User wants to kill a user */
   if (msg.numparams >= 2) { 
      struct ircconnclass *c;
      struct ircproxy *cp;
      int i;
        
      /* Check the user list */
      proxy = 0;
      c = connclasses;
      i = 0;
      while (c)  {  
         cp = ircnet_fetchclass(c);
         if (!cp) {
            c = c->next;
            continue;
         }
         if ((atoi(msg.params[1]) == ++i)
             || (cp->client_host
                 && !irc_strcasecmp(msg.params[1], cp->client_host))
             || (cp->servername
                 && !irc_strcasecmp(msg.params[1], cp->servername))
             || (cp->nickname
                 && !irc_strcasecmp(msg.params[1], cp->nickname))) {
            proxy = cp;
            break;
         }
         c = c->next;
      }
      
      if (proxy) {
         net_send(proxy->client_sock, ":dircproxy!dircproxy@localhost NOTICE %s :%s\r\n",cp->nickname, msg.paramstarts[2]);
      } else {
         ircclient_send_numeric(p, 401, "No such user, use /DIRCPROXY USERS to see them");
      }
   }
	 
}
   
   
  /* /DIRCPROXY USERS handler */
void _ircclient_handle_users(struct ircproxy *p, struct ircmessage msg) {
  struct ircconnclass *c;
  struct ircproxy *cp;
  int i;

  c = connclasses;
  i = 0;

  ircclient_send_notice(p, "Connection classes:");

  while (c) {
    cp = ircnet_fetchclass(c);
    if (!cp) {
      c = c->next;
      continue;
    }

    ircclient_send_notice(p, "-%s %2d. %s -> %s (%s)",
                          (cp == p ? ">" : " "), ++i,
                          cp->client_host ? cp->client_host : "(none)",
                          cp->servername ? cp->servername : "(none)",
                          cp->nickname ? cp->nickname : "no nickname");
    c = c->next;
  }
}

  /* /DIRCPROXY RECALL handler */
void _ircclient_handle_recall(struct ircproxy *p, struct ircmessage msg) {
  char *src, *filter;
  long start, lines;

  /* User wants to recall stuff from log files */
  src = filter = 0;
  start = -1;
  lines = 0;

  if (msg.numparams >= 4) {
    src = msg.params[1];
    start = atol(msg.params[2]);
    lines = atol(msg.params[3]);
  } else if (msg.numparams >= 3) {
    if (!irc_strcasecmp(msg.params[2], "ALL")) {
      src = msg.params[1];
      lines = -1;
    } else if (strspn(msg.params[1], "0123456789")
               == strlen(msg.params[1])) {
      start = atol(msg.params[1]);
      lines = atol(msg.params[2]);
    } else {
      src = msg.params[1];
      lines = atol(msg.params[2]);
    }
  } else if (msg.numparams >= 2) {
    if (!irc_strcasecmp(msg.params[1], "ALL")) {
      lines = -1;
    } else {
      lines = atol(msg.params[1]);
    }
  } else {
    ircclient_send_numeric(p, 461, ":Not enough parameters");
  }

  if (src && !irc_strcasecmp(src, "SERVER")) {
    src = 0;
  } else if (src) {
    struct ircchannel *c;

    c = ircnet_fetchchannel(p, src);
    if (!c) {
      filter = src;
      src = p->nickname;
    }
  } else {
    src = p->nickname;
  }

  irclog_recall(p, src, start, lines, filter);
}

  /* PRIVMSG handler */
int _ircclient_handle_privmsg(struct ircproxy *p, struct ircmessage msg) {
   int squelch = 0;

  if (msg.numparams >= 2) {
    struct strlist *list, *s;
    char *str;

    ircprot_stripctcp(msg.params[1], &str, &list);

    /* Privmsgs from us get logged */
    if (str && strlen(str)) {
      char *tmp;

      tmp = x_sprintf("%s!%s@%s", p->nickname, p->username,
                      p->hostname);
      irclog_log(p, IRC_LOG_MSG, msg.params[0], tmp, "%s", str);
      free(tmp);
    }
    free(str);

    /* Handle CTCP */
    str = x_strdup(msg.params[1]);
    s = list;
    while (s) {
      struct ctcpmessage cmsg;
      struct strlist *n;
      char *unquoted;
      int r;

      n = s->next;
      r = ircprot_parsectcp(s->str, &cmsg);
      unquoted = s->str;
      free(s);
      s = n;
      if (r == -1) {
        free(unquoted);
        continue;
      }

      if (!strcmp(cmsg.cmd, "ACTION")) {
        char *tmp;

        tmp = x_sprintf("%s!%s@%s", p->nickname, p->username,
                        p->hostname);
	if (cmsg.paramstarts)	   
	   irclog_log(p, IRC_LOG_ACTION, msg.params[0], tmp, "%s", cmsg.paramstarts[0]);
	else 
	   irclog_log(p, IRC_LOG_ACTION, msg.params[0], tmp, NULL);	 
        free(tmp);

      } else if (!strcmp(cmsg.cmd, "DCC")
                 && p->conn_class->dcc_proxy_outgoing) {
        struct sockaddr_in vis_addr;
        int len;

        /* We need our local address to do anything DCC related */
        len = sizeof(struct sockaddr_in);
        if (getsockname(p->server_sock, (struct sockaddr *)&vis_addr,
                         &len)) {
          syscall_fail("getsockname", "", 0);

        } else if ((cmsg.numparams >= 4)
                   && (!irc_strcasecmp(cmsg.params[0], "CHAT")
                       || !irc_strcasecmp(cmsg.params[0], "SEND"))) {
          char *tmp, *ptr, *dccmsg, *rejmsg;
          struct in_addr l_addr, r_addr;
          int l_port, r_port, t_port;
          char *rest = 0;
          int type = 0;

          /* Find out what type of DCC request this is */
          if (!irc_strcasecmp(cmsg.params[0], "CHAT")) {
            type = DCC_CHAT;
          } else if (!irc_strcasecmp(cmsg.params[0], "SEND")) {
            if (p->conn_class->dcc_send_fast) {
              type = DCC_SEND_FAST;
            } else {
              type = DCC_SEND_SIMPLE;
            }
          }

          /* Check whether there's a tunnel port */
          t_port = 0;
          if (p->conn_class->dcc_tunnel_outgoing)
            t_port = dns_portfromserv(p->conn_class->dcc_tunnel_outgoing);

          /* Eww, host order, how the hell does this even work
             between machines of a different byte order? */
          if (!t_port) {
            r_addr.s_addr = strtoul(cmsg.params[2], (char **)NULL, 10);
            r_port = atoi(cmsg.params[3]);
          } else {
            r_addr.s_addr = INADDR_LOOPBACK;
            r_port = ntohs(t_port);
          }
          l_addr.s_addr = ntohl(vis_addr.sin_addr.s_addr);
          if (cmsg.numparams >= 5)
            rest = cmsg.paramstarts[4];

          /* Strip out this CTCP from the message, replacing it in
             a moment with dccmsg */
          tmp = x_sprintf("\001%s\001", unquoted);
          ptr = strstr(str, tmp);
          dccmsg = 0;

          /* Save this in case we need it later */
          rejmsg = x_sprintf(":%s NOTICE %s :\001DCC REJECT %s %s",
                             msg.params[0], p->nickname,
                             cmsg.params[0], cmsg.params[1]);

          /* Set up a dcc proxy */
          if (ptr && !dccnet_new(type, p->conn_class->dcc_proxy_timeout,
                                 p->conn_class->dcc_proxy_ports,
                                 p->conn_class->dcc_proxy_ports_sz,
                                 &l_port, r_addr, r_port, 0, 0,
                                 DCCN_FUNCTION(_ircclient_send_dccreject),
                                 p, rejmsg, 0)) {
            char *me_tmp;

            dccmsg = x_sprintf("\001DCC %s %s %lu %u%s%s\001",
                               cmsg.params[0], cmsg.params[1],
                               l_addr.s_addr, l_port,
                               (rest ? " " : ""), (rest ? rest : ""));

            me_tmp = x_sprintf("%s!%s@%s", p->nickname, p->username,
                               p->hostname);
            irclog_log(p, IRC_LOG_CTCP, msg.params[0], me_tmp,
                       "Sent DCC %s Request", cmsg.params[0]);
            free(me_tmp);

          } else if (ptr) {
            dccmsg = x_strdup("");
            _ircclient_send_dccreject(p, rejmsg,
                                      "Couldn't establish proxy");
          }

          /* Don't need this now */
          free(rejmsg);

          /* Cut out the old CTCP and replace with dccmsg */
          if (ptr) {
            char *oldstr;

            *ptr = 0;
            ptr += strlen(tmp);

            oldstr = str;
            str = x_sprintf("%s%s%s", oldstr, dccmsg, ptr);

            free(oldstr);
            free(dccmsg);
          }

          free(tmp);

        } else {
          /* Unknown DCC */
	   if (cmsg.numparams > 0)
	     debug("Unknown or Unimplemented DCC request - %s", cmsg.params[0]);
        }

      } else {
        char *tmp;

        tmp = x_sprintf("%s!%s@%s", p->nickname, p->username,
                        p->hostname);
	if (cmsg.numparams > 0)
	   irclog_log(p, IRC_LOG_CTCP, msg.params[0], tmp, "Sent CTCP %s", cmsg.params[0]);
        free(tmp);
      }

      ircprot_freectcp(&cmsg);
      free(unquoted);
    }

    /* Send str */
    if (strlen(str))
      net_send(p->server_sock, ":%s PRIVMSG %s :%s\r\n",
               (msg.src.orig ? msg.src.orig : p->nickname),
               msg.params[0], str);
    squelch = 1;
    free(str);
  }

  if (p->conn_class->idle_maxtime)
    ircserver_resetidle(p);

  return squelch;
}

  /* /DIRCPROXY HELP handler */
void _ircclient_handle_help(struct ircproxy *p, struct ircmessage msg) {
  char **help_page;

  help_page = 0;

  if ((msg.numparams >= 2) && strlen(msg.params[1])) {
    if (!irc_strcasecmp(msg.params[1], "RECALL")) {
      help_page = command_help[I_HELP_RECALL];
    } else if (p->conn_class->allow_persist
               && !irc_strcasecmp(msg.params[1], "PERSIST")) {
      help_page = command_help[I_HELP_PERSIST];
    } else if (!irc_strcasecmp(msg.params[1], "RELOAD")) {
      help_page = command_help[I_HELP_RELOAD];
    } else if (!irc_strcasecmp(msg.params[1], "DETACH")) {
      help_page = command_help[I_HELP_DETACH];
    } else if (!irc_strcasecmp(msg.params[1], "QUIT")) {
      help_page = command_help[I_HELP_QUIT];
    } else if (!irc_strcasecmp(msg.params[1], "MOTD")) {
      help_page = command_help[I_HELP_MOTD];
    } else if (p->conn_class->allow_die
               && !irc_strcasecmp(msg.params[1], "DIE")) {
      help_page = command_help[I_HELP_DIE];
    } else if (!irc_strcasecmp(msg.params[1], "SERVERS")) {
      help_page = command_help[I_HELP_SERVERS];
    } else if (p->conn_class->allow_jump
               && !irc_strcasecmp(msg.params[1], "JUMP")) {
      help_page = (p->conn_class->allow_jump_new
                   ? command_help[I_HELP_JUMP_NEW] : command_help[I_HELP_JUMP]);
    } else if (p->conn_class->allow_host
               && !irc_strcasecmp(msg.params[1], "HOST")) {
      help_page = command_help[I_HELP_HOST];
    } else if (!irc_strcasecmp(msg.params[1], "STATUS")) {
      help_page = command_help[I_HELP_STATUS];
    } else if (!irc_strcasecmp(msg.params[1], "USERS")) {
      help_page = command_help[I_HELP_USERS];
    } else if (!irc_strcasecmp(msg.params[1], "KILL")) {
      help_page = command_help[I_HELP_KILL];
    } else if (!irc_strcasecmp(msg.params[1], "NOTIFY")) {
      help_page = command_help[I_HELP_NOTIFY]; 
    } else if (!irc_strcasecmp(msg.params[1], "HELP")) {
      help_page = command_help[I_HELP_HELP];
    } else {
      help_page = command_help[I_HELP_INDEX];
    }

  } else {
    help_page = command_help[I_HELP_INDEX];
  }

  if (help_page) {
    int i;

    i = 0;
    ircclient_send_notice(p, "%s %s help", PACKAGE, VERSION);
    while (help_page[i]) {
      ircclient_send_notice(p, "- %s", help_page[i]);
      i++;
    }

    if (help_page == command_help[I_HELP_INDEX]) {
      ircclient_send_notice(p, "-     HELP      "
                           "(help on /dircproxy commands)");
      ircclient_send_notice(p, "-     MOTD      "
                           "(show dircproxy message of the day)");
      ircclient_send_notice(p, "-     STATUS    "
                            "(show dircproxy status information)");
      ircclient_send_notice(p, "-     RECALL    "
                            "(recall text from log files)");
      ircclient_send_notice(p, "-     RELOAD    "
                            "(reload configuration file)");
      ircclient_send_notice(p, "-     DETACH    "
                            "(detach from dircproxy)");
      if (p->conn_class->allow_persist)
        ircclient_send_notice(p, "-     PERSIST   "
                              "(keep session after detach)");
      ircclient_send_notice(p, "-     QUIT      "
                            "(end dircproxy session)");
      if (p->conn_class->allow_die)
        ircclient_send_notice(p, "-     DIE       "
                              "(terminate dircproxy)");
      if (p->conn_class->allow_users)
        ircclient_send_notice(p, "-     USERS     "
                              "(show users using dircproxy)");
      if (p->conn_class->allow_kill)
        ircclient_send_notice(p, "-     KILL      "
                              "(terminate a user's session)");
      if (p->conn_class->allow_notify)
	ircclient_send_notice(p, "-     NOTIFY    "
			      "(send a notice to a user's session");
      ircclient_send_notice(p, "-     SERVERS   "
                            "(show servers list)");
      if (p->conn_class->allow_jump)
        ircclient_send_notice(p, "-     JUMP      "
                              "(jump to a different server)");
      if (p->conn_class->allow_host)
        ircclient_send_notice(p, "-     HOST      "
                              "(change your visible hostname)");

      i = 0;
      while (command_help[I_HELP_INDEX_END][i]) {
        ircclient_send_notice(p, "- %s", command_help[I_HELP_INDEX_END][i]);
        i++;
      }
    }

    ircclient_send_notice(p, "-");
  }
}
